home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gximage.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  11.0 KB  |  304 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gximage.h,v 1.2 2000/09/19 19:00:38 lpd Exp $ */
  20. /* Default image rendering state structure */
  21. /* Requires gxcpath.h, gxdevmem.h, gxdcolor.h, gzpath.h */
  22.  
  23. #ifndef gximage_INCLUDED
  24. #  define gximage_INCLUDED
  25.  
  26. #include "gsiparam.h"
  27. #include "gxcspace.h"
  28. #include "strimpl.h"        /* for sisparam.h */
  29. #include "sisparam.h"
  30. #include "gxdda.h"
  31. #include "gxiclass.h"
  32. #include "gxiparam.h"
  33. #include "gxsample.h"
  34.  
  35. /* Define the abstract type for the image enumerator state. */
  36. /*typedef struct gx_image_enum_s gx_image_enum;*/  /* in gxiclass.h */
  37.  
  38. /*
  39.  * Incoming samples may go through two different transformations:
  40.  *
  41.  *      - For N-bit input samples with N <= 8, N-to-8-bit expansion
  42.  *      may involve a lookup map.  Currently this map is either an
  43.  *      identity function or a subtraction from 1 (inversion).
  44.  *
  45.  *      - The 8-bit or frac expanded sample may undergo decoding (a linear
  46.  *      transformation) before being handed off to the color mapping
  47.  *      machinery.
  48.  *
  49.  * If the decoding function's range is [0..1], we fold it into the
  50.  * expansion lookup; otherwise we must compute it separately.
  51.  * For speed, we distinguish 3 different cases of the decoding step:
  52.  */
  53. typedef enum {
  54.     sd_none,            /* decoded during expansion */
  55.     sd_lookup,            /* use lookup_decode table */
  56.     sd_compute            /* compute using base and factor */
  57. } sample_decoding;
  58. typedef struct sample_map_s {
  59.  
  60.     sample_lookup_t table;
  61.  
  62.     /*
  63.      * If an 8-bit fraction doesn't represent the decoded value
  64.      * accurately enough, but the samples have 4 bits or fewer,
  65.      * we precompute the decoded values into a table.
  66.      * Different entries are used depending on bits/sample:
  67.      *      1,8,12 bits/sample: 0,15
  68.      *      2 bits/sample: 0,5,10,15
  69.      *      4 bits/sample: all
  70.      */
  71.  
  72.     float decode_lookup[16];
  73. #define decode_base decode_lookup[0]
  74. #define decode_max decode_lookup[15]
  75.  
  76.     /*
  77.      * In the worst case, we have to do the decoding on the fly.
  78.      * The value is base + sample * factor, where the sample is
  79.      * an 8-bit (unsigned) integer or a frac.
  80.      */
  81.  
  82.     double decode_factor;
  83.  
  84.     sample_decoding decoding;
  85.  
  86.     /*
  87.      * If decoding is sd_none for a non-mask image, we still need to know
  88.      * whether the table includes an inversion, so that we can transform
  89.      * mask values correctly.
  90.      */
  91.  
  92.     bool inverted;
  93.  
  94. } sample_map;
  95.  
  96. /* Decode an 8-bit sample into a floating point color component. */
  97. /* penum points to the gx_image_enum structure. */
  98. #define decode_sample(sample_value, cc, i)\
  99.   switch ( penum->map[i].decoding )\
  100.   {\
  101.   case sd_none:\
  102.     cc.paint.values[i] = (sample_value) * (1.0 / 255.0);  /* faster than / */\
  103.     break;\
  104.   case sd_lookup:    /* <= 4 significant bits */\
  105.     cc.paint.values[i] =\
  106.       penum->map[i].decode_lookup[(sample_value) >> 4];\
  107.     break;\
  108.   case sd_compute:\
  109.     cc.paint.values[i] =\
  110.       penum->map[i].decode_base + (sample_value) * penum->map[i].decode_factor;\
  111.   }
  112.  
  113. /* Decode a frac value similarly. */
  114. #define decode_frac(frac_value, cc, i)\
  115.   cc.paint.values[i] =\
  116.     penum->map[i].decode_base + (frac_value) * penum->map[i].decode_factor
  117.  
  118. /*
  119.  * Declare the pointer that holds the 12-bit unpacking procedure
  120.  * if 12-bit samples are supported, 0 otherwise.
  121.  */
  122. extern const sample_unpack_proc_t sample_unpack_12_proc;
  123.  
  124. /* Define the distinct postures of an image. */
  125. /* Each posture includes its reflected variant. */
  126. typedef enum {
  127.     image_portrait = 0,        /* 0 or 180 degrees */
  128.     image_landscape,        /* 90 or 270 degrees */
  129.     image_skewed        /* any other transformation */
  130. } image_posture;
  131.  
  132. /*
  133.  * Define an entry in the image color table.  For single-source-plane
  134.  * images, the table index is the sample value, and the key is not used;
  135.  * for multiple-plane (color) images, the table index is a hash of the key,
  136.  * which is the concatenation of the source pixel components.
  137.  * "Clue" = Color LookUp Entry (by analogy with CLUT).
  138.  */
  139. typedef struct gx_image_clue_s {
  140.     gx_device_color dev_color;
  141.     bits32 key;
  142. } gx_image_clue;
  143.  
  144. /* Main state structure */
  145.  
  146. #ifndef gx_device_clip_DEFINED
  147. #  define gx_device_clip_DEFINED
  148. typedef struct gx_device_clip_s gx_device_clip;
  149. #endif
  150.  
  151. #ifndef gx_device_rop_texture_DEFINED
  152. #  define gx_device_rop_texture_DEFINED
  153. typedef struct gx_device_rop_texture_s gx_device_rop_texture;
  154. #endif
  155.  
  156. struct gx_image_enum_s {
  157.     gx_image_enum_common;
  158.     /* We really want the map structure to be long-aligned, */
  159.     /* so we choose shorter types for some flags. */
  160.     /* Following are set at structure initialization */
  161.     byte bps;            /* bits per sample: 1, 2, 4, 8, 12 */
  162.     byte unpack_bps;        /* bps for computing unpack proc, */
  163.                 /* set to 8 if no unpacking */
  164.     byte log2_xbytes;        /* log2(bytes per expanded sample): */
  165.                 /* 0 if bps <= 8, log2(sizeof(frac)) */
  166.                 /* if bps > 8 */
  167.     byte spp;            /* samples per pixel */
  168.     gs_image_alpha_t alpha;    /* Alpha from image structure */
  169.     struct mc_ {
  170.     uint values[GS_IMAGE_MAX_COMPONENTS * 2]; /* MaskColor values, */
  171.                 /* always as ranges, guaranteed in range */
  172.                 /* and in order (v0 <= v1) */
  173.     bits32 mask, test;    /* (if spp > 1, bps <= 8) */
  174.                 /* mask & test value for quick filtering */
  175.     bool exact;        /* (if spp > 1, bps <= 8) */
  176.                 /* if true, mask/test filter is exact */
  177.     } mask_color;        /* (if ImageType 4) */
  178.     byte use_mask_color;    /* true if color masking is being used */
  179.     /*byte num_planes; */    /* (in common part) */
  180.     byte spread;        /* (spp if multi-plane, 1 if not) */
  181.                 /* << log2_xbytes */
  182.     byte masked;        /* 0 = [color]image, 1 = imagemask */
  183.     byte interpolate;        /* true if Interpolate requested */
  184.     gs_matrix matrix;        /* image space -> device space */
  185.     struct r_ {
  186.     int x, y, w, h;        /* subrectangle being rendered */
  187.     } rect;
  188.     gs_fixed_point x_extent, y_extent;    /* extent of one row of rect */
  189.     SAMPLE_UNPACK_PROC((*unpack));
  190.     irender_proc((*render));
  191.     const gs_imager_state *pis;
  192.     const gs_color_space *pcs;    /* color space of image */
  193.     gs_memory_t *memory;
  194.     byte *buffer;        /* for expanding samples to a */
  195.                 /* byte or frac */
  196.     uint buffer_size;
  197.     byte *line;            /* buffer for an output scan line */
  198.     uint line_size;
  199.     uint line_width;        /* width of line in device pixels */
  200.     image_posture posture;
  201.     byte use_rop;        /* true if CombineWithColor requested */
  202.     byte clip_image;        /* mask, see below */
  203.     /* Either we are clipping to a rectangle, in which case */
  204.     /* the individual x/y flags may be set, or we are clipping */
  205.     /* to a general region, in which case only clip_region */
  206.     /* is set. */
  207. #define image_clip_xmin 1
  208. #define image_clip_xmax 2
  209. #define image_clip_ymin 4
  210. #define image_clip_ymax 8
  211. #define image_clip_region 0x10
  212.     byte slow_loop;        /* true if must use slower loop */
  213.                 /* (if needed) */
  214.     byte device_color;        /* true if device color space and */
  215.                 /* standard decoding */
  216.     gs_fixed_rect clip_outer;    /* outer box of clip path */
  217.     gs_fixed_rect clip_inner;    /* inner box of clip path */
  218.     gs_logical_operation_t log_op;    /* logical operation */
  219.     fixed adjust;        /* adjustment when rendering */
  220.                 /* characters */
  221.     fixed dxx, dxy;        /* fixed versions of matrix */
  222.                 /* components (as needed) */
  223.     gx_device_clip *clip_dev;    /* clipping device (if needed) */
  224.     gx_device_rop_texture *rop_dev;    /* RasterOp device (if needed) */
  225.     stream_image_scale_state *scaler;    /* scale state for Interpolate */
  226.                 /* (if needed) */
  227.     /* Following are updated dynamically */
  228.     int y;            /* next source y */
  229.     gs_int_point used;        /* amount of data already used, if */
  230.                 /* interrupted by error */
  231.     gs_fixed_point cur, prev;    /* device x, y of current & */
  232.                 /* previous row */
  233.     struct dd_ {
  234.     gx_dda_fixed_point row;    /* DDA for row origin, has been */
  235.                 /* advanced when render proc called */
  236.     gx_dda_fixed_point strip;  /* row + rect.x */
  237.     gx_dda_fixed_point pixel0;    /* DDA for first pixel to render, */
  238.                 /* strip + used.x */
  239.     } dda;
  240.     int line_xy;        /* x or y value at start of buffered line */
  241.     int xi_next;        /* expected xci of next row */
  242.                 /* (landscape only) */
  243.     gs_int_point xyi;        /* integer origin of row */
  244.                 /* (Interpolate only) */
  245.     int yci, hci;        /* integer y & h of row (portrait) */
  246.     int xci, wci;        /* integer x & w of row (landscape) */
  247.     /* The maps are set at initialization.  We put them here */
  248.     /* so that the scalars will have smaller offsets. */
  249.     sample_map map[GS_IMAGE_MAX_COMPONENTS];
  250.     /* Entries 0 and 255 of the following are set at initialization */
  251.     /* for monochrome images; other entries are updated dynamically. */
  252.     gx_image_clue clues[256];
  253. #define icolor0 clues[0].dev_color
  254. #define icolor1 clues[255].dev_color
  255. };
  256.  
  257. /* Enumerate the pointers in an image enumerator. */
  258. #define gx_image_enum_do_ptrs(m)\
  259.   m(0,pis) m(1,pcs) m(2,dev) m(3,buffer) m(4,line)\
  260.   m(5,clip_dev) m(6,rop_dev) m(7,scaler)
  261. #define gx_image_enum_num_ptrs 8
  262. #define private_st_gx_image_enum() /* in gsimage.c */\
  263.   gs_private_st_composite(st_gx_image_enum, gx_image_enum, "gx_image_enum",\
  264.     image_enum_enum_ptrs, image_enum_reloc_ptrs)
  265.  
  266. /* Compare two device colors for equality. */
  267. /* We can special-case this for speed later if we care. */
  268. #define dev_color_eq(devc1, devc2)\
  269.   gx_device_color_equal(&(devc1), &(devc2))
  270.  
  271. /*
  272.  * Scale a pair of mask_color values to match the scaling of each sample to
  273.  * a full byte, and complement and swap them if the map incorporates
  274.  * a Decode = [1 0] inversion.
  275.  */
  276. void gx_image_scale_mask_colors(P2(gx_image_enum *penum,
  277.                    int component_index));
  278.  
  279. /*
  280.  * Do common initialization for processing an ImageType 1 or 4 image.
  281.  * Allocate the enumerator and fill in the following members:
  282.  *    rect
  283.  */
  284. int
  285. gx_image_enum_alloc(P4(const gs_image_common_t * pic,
  286.                const gs_int_rect * prect,
  287.                gs_memory_t * mem, gx_image_enum **ppenum));
  288.  
  289. /*
  290.  * Finish initialization for processing an ImageType 1 or 4 image.
  291.  * Assumes the following members of *penum are set in addition to those
  292.  * set by gx_image_enum_alloc:
  293.  *    alpha, use_mask_color, mask_color (if use_mask_color is true),
  294.  *    masked, adjust
  295.  */
  296. int
  297. gx_image_enum_begin(P8(gx_device * dev, const gs_imager_state * pis,
  298.                const gs_matrix *pmat, const gs_image_common_t * pic,
  299.                const gx_drawing_color * pdcolor,
  300.                const gx_clip_path * pcpath,
  301.                gs_memory_t * mem, gx_image_enum *penum));
  302.  
  303. #endif /* gximage_INCLUDED */
  304.